﻿using LibraryProject.Model;
using LibraryProject.Tool;
using SQLite;

namespace LibraryProject.Service.Implement;

public class LinkFileService : ILinkFileService {
    // 初始化数据库链接
    private SQLiteAsyncConnection Connection =>
        SqLiteConnectionPro.Connection;

    // 创建表
    public async Task<int> CreateTable() {
        return await SqLiteConnectionPro.CreateTable<LinkFile>("linkFile");
    }

    // 插入一条数据
    public async Task<int> InsertOne(LinkFile linkFile) {
        return await Connection.InsertAsync(linkFile);
    }

    // 批量插入数据
    public async Task InsertAll(List<LinkFile> linkFiles) {
        foreach (var linkFile in linkFiles) {
            await InsertOne(linkFile);
        }
    }

    // 修改数据的Name
    public async Task UpdateName(LinkFile linkFile) {
        var sql = $"update linkFile set name = '{linkFile.Name}' where id = {linkFile.Id}";
        await Connection.ExecuteAsync(sql);
    }

    // 删除数据
    public async Task DeleteById(int id) {
        var sql = $"delete from linkFile where id = {id}";
        await Connection.ExecuteAsync(sql);
    }

    // 查询所有LinkFile
    public async Task<List<LinkFile>> QueryAll() {
        var list = await Connection.Table<LinkFile>().ToListAsync();
        return list;
    }

    // 删除表
    public async Task<int> DeleteTable() {
        return await Connection.DropTableAsync<LinkFile>();
    }

    // 初始化数据库
    public async Task<bool> InitDb() {
        // 删除表，确保每次都是重新创建
        await DeleteTable();

        // 创建表
        var result = await CreateTable();
        if (result == -1) return false; // 如果表创建失败，直接返回false

        // 插入初始化数据
        await InsertAll(LinkFileTool.SampleLinkFiles());

        return true;
    }

    // 整理所有的LinkFile，并用树形结构返回
    public async Task<LinkFile> SortLinkFileList() {
        // 1. 初始化局部变量
        var list = await QueryAll(); // 获取所有LinkFile
        var root = new LinkFile() { Name = "root", IsDir = 1, ParentId = -1, Id = 0 }; // 创建根节点
        var hashMap = new Dictionary<int, List<LinkFile>> {
            { root.Id, new List<LinkFile>() }
        }; // 创建hashMap，用于存放key是LinkFile的id，value是LinkFile的childrenList

        // 2. 将所有LinkFile的id作为key，value是一个空的List<LinkFile>，放入hashMap
        foreach (var t in list) {
            hashMap.Add(t.Id, new List<LinkFile>());
        }

        // 3. 遍历所有LinkFile，根据ParentId，将LinkFile放入对应的List<LinkFile>中
        // hashMap中保存的是LinkFile的childrenList，但是childrenList中的LinkFile没有childrenList的信息
        // 也就是只有一层信息
        foreach (var t in list) {
            // 如果t的parent存在，将t放入t的parent的childrenList中
            if (hashMap.ContainsKey(t.ParentId)) {
                hashMap[t.ParentId].Add(t);
            }
        }

        // 4. 组装root的childrenList
        root.ChildrenList = hashMap[root.Id];
        // 5. 调用递归
        AddChild(hashMap, root);

        return root;
    }

    // SortLinkFileList()调用的递归函数
    private static void AddChild(Dictionary<int, List<LinkFile>> dictionary, LinkFile root) {
        // 循环遍历局部变量root的childrenList
        for (var i = 0; i < root.ChildrenList.Count; i++) {
            root.ChildrenList[i].ChildrenList = dictionary[root.ChildrenList[i].Id];
            AddChild(dictionary, root.ChildrenList[i]);
        }
    }
}